{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'google.colab'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-1-35bef2f5146d>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# this mounts your Google Drive to the Colab VM.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[1;32mfrom\u001b[0m \u001b[0mgoogle\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcolab\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mdrive\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[0mdrive\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmount\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'/content/drive'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mforce_remount\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;31m# enter the foldername in your Drive where you have saved the unzipped\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'google.colab'"
     ]
    }
   ],
   "source": [
    "# this mounts your Google Drive to the Colab VM.\n",
    "from google.colab import drive\n",
    "drive.mount('/content/drive', force_remount=True)\n",
    "\n",
    "# enter the foldername in your Drive where you have saved the unzipped\n",
    "# assignment folder, e.g. 'cs231n/assignments/assignment3/'\n",
    "FOLDERNAME = None\n",
    "assert FOLDERNAME is not None, \"[!] Enter the foldername.\"\n",
    "\n",
    "# now that we've mounted your Drive, this ensures that\n",
    "# the Python interpreter of the Colab VM can load\n",
    "# python files from within it.\n",
    "import sys\n",
    "sys.path.append('/content/drive/My Drive/{}'.format(FOLDERNAME))\n",
    "\n",
    "# this downloads the CIFAR-10 dataset to your Drive\n",
    "# if it doesn't already exist.\n",
    "%cd drive/My\\ Drive/$FOLDERNAME/cs231n/datasets/\n",
    "!bash get_datasets.sh\n",
    "%cd /content"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Fully-Connected Neural Nets\n",
    "In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
    "\n",
    "```python\n",
    "def layer_forward(x, w):\n",
    "  \"\"\" Receive inputs x and weights w \"\"\"\n",
    "  # Do some computations ...\n",
    "  z = # ... some intermediate value\n",
    "  # Do some more computations ...\n",
    "  out = # the output\n",
    "   \n",
    "  cache = (x, w, z, out) # Values we need to compute gradients\n",
    "   \n",
    "  return out, cache\n",
    "```\n",
    "\n",
    "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
    "\n",
    "```python\n",
    "def layer_backward(dout, cache):\n",
    "  \"\"\"\n",
    "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
    "  and compute derivative with respect to inputs.\n",
    "  \"\"\"\n",
    "  # Unpack cache values\n",
    "  x, w, z, out = cache\n",
    "  \n",
    "  # Use values in cache to compute derivatives\n",
    "  dx = # Derivative of loss with respect to x\n",
    "  dw = # Derivative of loss with respect to w\n",
    "  \n",
    "  return dx, dw\n",
    "```\n",
    "\n",
    "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
    "\n",
    "In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=========== You can safely ignore the message below if you are NOT working on ConvolutionalNetworks.ipynb ===========\n",
      "\tYou will need to compile a Cython extension for a portion of this assignment.\n",
      "\tThe instructions to do this will be given in a section of the notebook below.\n",
      "\tThere will be an option for Colab users and another for Jupyter (local) users.\n"
     ]
    }
   ],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('X_train: ', (49000, 3, 32, 32))\n",
      "('y_train: ', (49000,))\n",
      "('X_val: ', (1000, 3, 32, 32))\n",
      "('y_val: ', (1000,))\n",
      "('X_test: ', (1000, 3, 32, 32))\n",
      "('y_test: ', (1000,))\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in list(data.items()):\n",
    "  print(('%s: ' % k, v.shape))\n",
    "type(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: forward\n",
    "Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n",
    "\n",
    "Once you are done you can test your implementaion by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 4, 5, 6)\n",
      "Testing affine_forward function:\n",
      "difference:  9.769849468192957e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_forward function\n",
    "\n",
    "num_inputs = 2\n",
    "input_shape = (4, 5, 6)\n",
    "output_dim = 3\n",
    "\n",
    "input_size = num_inputs * np.prod(input_shape)#prod计算数组内部的积\n",
    "weight_size = output_dim * np.prod(input_shape)\n",
    "\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)#加星号会把变量变成一个个独立的元素\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
    "print(x.shape)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
    "\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "\n",
    "# Compare your output with ours. The error should be around e-9 or less.\n",
    "print('Testing affine_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: backward\n",
    "Now implement the `affine_backward` function and test your implementation using numeric gradient checking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_backward function:\n",
      "dx error:  5.399100368651805e-11\n",
      "dw error:  9.904211865398145e-11\n",
      "db error:  2.4122867568119087e-11\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# The error should be around e-10 or less\n",
    "print('Testing affine_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=np.random.rand(16)\n",
    "a.reshape(4,-1)\n",
    "a[np.where(a<0)]\n",
    "b=a\n",
    "b[:]=0\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: forward\n",
    "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_forward function:\n",
      "difference:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# Test the relu_forward function\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "\n",
    "out, _ = relu_forward(x)\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# Compare your output with ours. The error should be on the order of e-8\n",
    "print('Testing relu_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: backward\n",
    "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_backward function:\n",
      "dx error:  3.2756349136310288e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# The error should be on the order of e-12\n",
    "print('Testing relu_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 1: \n",
    "\n",
    "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
    "1. Sigmoid\n",
    "2. ReLU\n",
    "3. Leaky ReLU\n",
    "\n",
    "## Answer:\n",
    "[Relu]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Sandwich\" layers\n",
    "There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n",
    "\n",
    "For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_relu_forward and affine_relu_backward:\n",
      "dx error:  2.299579177309368e-11\n",
      "dw error:  8.162011105764925e-11\n",
      "db error:  7.826724021458994e-12\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "# Relative error should be around e-10 or less\n",
    "print('Testing affine_relu_forward and affine_relu_backward:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss layers: Softmax and SVM\n",
    "You implemented these loss functions in the last assignment, so we'll give them to you for free here. You should still make sure you understand how they work by looking at the implementations in `cs231n/layers.py`.\n",
    "\n",
    "You can make sure that the implementations are correct by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing svm_loss:\n",
      "loss:  8.999602749096233\n",
      "dx error:  1.4021566006651672e-09\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.302545844500738\n",
      "dx error:  9.384673161989355e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = svm_loss(x, y)\n",
    "\n",
    "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
    "print('Testing svm_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
    "print('\\nTesting softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-layer network\n",
    "In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.\n",
    "\n",
    "Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing initialization ... \n",
      "Testing test-time forward pass ... \n",
      "Testing training loss (no regularization)\n",
      "Running numeric gradient check with reg =  0.0\n",
      "W1 relative error: 1.83e-08\n",
      "W2 relative error: 3.12e-10\n",
      "b1 relative error: 9.83e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 2.53e-07\n",
      "W2 relative error: 2.85e-08\n",
      "b1 relative error: 1.56e-08\n",
      "b2 relative error: 7.76e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "\n",
    "std = 1e-3\n",
    "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('Testing initialization ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
    "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
    "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
    "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
    "\n",
    "#检查向前传播\n",
    "print('Testing test-time forward pass ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "scores = model.loss(X)\n",
    "correct_scores = np.asarray(\n",
    "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
    "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
    "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
    "\n",
    "print('Testing training loss (no regularization)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n",
    "\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n",
    "\n",
    "# Errors should be around e-7 or less\n",
    "for reg in [0.0, 0.7]:\n",
    "  print('Running numeric gradient check with reg = ', reg)\n",
    "  model.reg = reg\n",
    "  loss, grads = model.loss(X, y)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solver\n",
    "In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.\n",
    "\n",
    "Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "tln_solver_accuracy",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 4900) loss: 2.304060\n",
      "(Epoch 0 / 10) train acc: 0.116400; val_acc: 0.094000\n",
      "(Iteration 101 / 4900) loss: 1.847388\n",
      "(Iteration 201 / 4900) loss: 1.566161\n",
      "(Iteration 301 / 4900) loss: 1.781851\n",
      "(Iteration 401 / 4900) loss: 1.559552\n",
      "(Epoch 1 / 10) train acc: 0.449000; val_acc: 0.450000\n",
      "(Iteration 501 / 4900) loss: 1.458443\n",
      "(Iteration 601 / 4900) loss: 1.597901\n",
      "(Iteration 701 / 4900) loss: 1.525278\n",
      "(Iteration 801 / 4900) loss: 1.381351\n",
      "(Iteration 901 / 4900) loss: 1.437650\n",
      "(Epoch 2 / 10) train acc: 0.510600; val_acc: 0.475000\n",
      "(Iteration 1001 / 4900) loss: 1.531278\n",
      "(Iteration 1101 / 4900) loss: 1.466205\n",
      "(Iteration 1201 / 4900) loss: 1.441680\n",
      "(Iteration 1301 / 4900) loss: 1.368610\n",
      "(Iteration 1401 / 4900) loss: 1.364549\n",
      "(Epoch 3 / 10) train acc: 0.527200; val_acc: 0.505000\n",
      "(Iteration 1501 / 4900) loss: 1.335990\n",
      "(Iteration 1601 / 4900) loss: 1.529746\n",
      "(Iteration 1701 / 4900) loss: 1.241015\n",
      "(Iteration 1801 / 4900) loss: 1.483773\n",
      "(Iteration 1901 / 4900) loss: 1.163031\n",
      "(Epoch 4 / 10) train acc: 0.545800; val_acc: 0.510000\n",
      "(Iteration 2001 / 4900) loss: 1.290495\n",
      "(Iteration 2101 / 4900) loss: 1.274579\n",
      "(Iteration 2201 / 4900) loss: 1.282272\n",
      "(Iteration 2301 / 4900) loss: 1.072342\n",
      "(Iteration 2401 / 4900) loss: 1.105924\n",
      "(Epoch 5 / 10) train acc: 0.566200; val_acc: 0.517000\n",
      "(Iteration 2501 / 4900) loss: 1.257778\n",
      "(Iteration 2601 / 4900) loss: 1.265350\n",
      "(Iteration 2701 / 4900) loss: 1.137646\n",
      "(Iteration 2801 / 4900) loss: 1.058190\n",
      "(Iteration 2901 / 4900) loss: 1.205262\n",
      "(Epoch 6 / 10) train acc: 0.570400; val_acc: 0.519000\n",
      "(Iteration 3001 / 4900) loss: 1.295177\n",
      "(Iteration 3101 / 4900) loss: 1.176129\n",
      "(Iteration 3201 / 4900) loss: 0.968600\n",
      "(Iteration 3301 / 4900) loss: 1.023375\n",
      "(Iteration 3401 / 4900) loss: 1.234112\n",
      "(Epoch 7 / 10) train acc: 0.597400; val_acc: 0.523000\n",
      "(Iteration 3501 / 4900) loss: 0.945363\n",
      "(Iteration 3601 / 4900) loss: 1.221299\n",
      "(Iteration 3701 / 4900) loss: 1.279629\n",
      "(Iteration 3801 / 4900) loss: 1.173813\n",
      "(Iteration 3901 / 4900) loss: 1.240515\n",
      "(Epoch 8 / 10) train acc: 0.601200; val_acc: 0.538000\n",
      "(Iteration 4001 / 4900) loss: 1.243303\n",
      "(Iteration 4101 / 4900) loss: 1.027415\n",
      "(Iteration 4201 / 4900) loss: 1.129662\n",
      "(Iteration 4301 / 4900) loss: 1.243299\n",
      "(Iteration 4401 / 4900) loss: 1.048157\n",
      "(Epoch 9 / 10) train acc: 0.603000; val_acc: 0.527000\n",
      "(Iteration 4501 / 4900) loss: 1.118075\n",
      "(Iteration 4601 / 4900) loss: 1.055262\n",
      "(Iteration 4701 / 4900) loss: 0.912600\n",
      "(Iteration 4801 / 4900) loss: 1.141512\n",
      "(Epoch 10 / 10) train acc: 0.615000; val_acc: 0.527000\n"
     ]
    }
   ],
   "source": [
    "model = TwoLayerNet()\n",
    "solver = None\n",
    "\n",
    "##############################################################################\n",
    "# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least  #\n",
    "# 50% accuracy on the validation set.                                        #\n",
    "##############################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "solver = Solver(model, data,\n",
    "                    update_rule='sgd',\n",
    "                    optim_config={\n",
    "                      'learning_rate': 1e-3,\n",
    "                    },\n",
    "                    lr_decay=0.8,\n",
    "                    num_epochs=10, batch_size=100,num_train_samples=5000,\n",
    "                    print_every=100,verbose=True)\n",
    "pass\n",
    "solver.train()\n",
    "#为什么加了relu非线性算子之后准确率高了这么多？\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to visualize training loss and train / val accuracy\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.title('Accuracy')\n",
    "plt.plot(solver.train_acc_history, '-o', label='train')\n",
    "plt.plot(solver.val_acc_history, '-o', label='val')\n",
    "plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(loc='lower right')\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multilayer network\n",
    "Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n",
    "\n",
    "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n",
    "\n",
    "Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch/layer normalization; we will add those features soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial loss and gradient check\n",
    "\n",
    "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n",
    "\n",
    "For gradient checking, you should expect to see errors around 1e-7 or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.3004790897684924\n",
      "b1 relative error: 5.38e-09\n",
      "b2 relative error: 2.09e-09\n",
      "b3 relative error: 5.80e-11\n",
      "w1 relative error: 1.48e-07\n",
      "w2 relative error: 2.21e-05\n",
      "w3 relative error: 3.53e-07\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.052114776533016\n",
      "b1 relative error: 1.48e-08\n",
      "b2 relative error: 1.72e-09\n",
      "b3 relative error: 1.57e-10\n",
      "w1 relative error: 3.90e-09\n",
      "w2 relative error: 6.87e-08\n",
      "w3 relative error: 2.13e-08\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 3.14]:\n",
    "    print('Running check with reg = ', reg)\n",
    "    model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64)\n",
    "\n",
    "    loss, grads = model.loss(X, y)\n",
    "    print('Initial loss: ', loss)\n",
    "  \n",
    "  # Most of the errors should be on the order of e-7 or smaller.   \n",
    "  # NOTE: It is fine however to see an error for W2 on the order of e-5\n",
    "  # for the check when reg = 0.0\n",
    "    for name in sorted(grads):\n",
    "        f = lambda _: model.loss(X, y)[0]\n",
    "        grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "        print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the **learning rate** and **weight initialization scale** to overfit and achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 2.363542\n",
      "(Epoch 0 / 20) train acc: 0.220000; val_acc: 0.092000\n",
      "(Epoch 1 / 20) train acc: 0.240000; val_acc: 0.094000\n",
      "(Epoch 2 / 20) train acc: 0.460000; val_acc: 0.144000\n",
      "(Epoch 3 / 20) train acc: 0.540000; val_acc: 0.119000\n",
      "(Epoch 4 / 20) train acc: 0.600000; val_acc: 0.162000\n",
      "(Epoch 5 / 20) train acc: 0.600000; val_acc: 0.163000\n",
      "(Iteration 11 / 40) loss: 1.192993\n",
      "(Epoch 6 / 20) train acc: 0.760000; val_acc: 0.173000\n",
      "(Epoch 7 / 20) train acc: 0.780000; val_acc: 0.175000\n",
      "(Epoch 8 / 20) train acc: 0.820000; val_acc: 0.171000\n",
      "(Epoch 9 / 20) train acc: 0.940000; val_acc: 0.189000\n",
      "(Epoch 10 / 20) train acc: 0.940000; val_acc: 0.180000\n",
      "(Iteration 21 / 40) loss: 0.351593\n",
      "(Epoch 11 / 20) train acc: 0.960000; val_acc: 0.181000\n",
      "(Epoch 12 / 20) train acc: 0.980000; val_acc: 0.198000\n",
      "(Epoch 13 / 20) train acc: 0.960000; val_acc: 0.171000\n",
      "(Epoch 14 / 20) train acc: 0.980000; val_acc: 0.180000\n",
      "(Epoch 15 / 20) train acc: 0.980000; val_acc: 0.196000\n",
      "(Iteration 31 / 40) loss: 0.051008\n",
      "(Epoch 16 / 20) train acc: 0.980000; val_acc: 0.190000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.180000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.185000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.181000\n",
      "(Epoch 20 / 20) train acc: 0.980000; val_acc: 0.173000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a three-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 9.5e-3   # Experiment with this!\n",
    "learning_rate = 1e-2  # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100],\n",
    "              weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()\n",
    "#因为每一次权重初始化都不一样所以每一次训练结果相差都很大，但是如果epoch足够的话还是能够overfit的\n",
    "#另外权重大小和学习率的微小变化都会影响结果哦！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again, you will have to adjust the learning rate and weight initialization scale, but you should be able to achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 137.279425\n",
      "(Epoch 0 / 20) train acc: 0.160000; val_acc: 0.097000\n",
      "(Epoch 1 / 20) train acc: 0.220000; val_acc: 0.140000\n",
      "(Epoch 2 / 20) train acc: 0.340000; val_acc: 0.108000\n",
      "(Epoch 3 / 20) train acc: 0.500000; val_acc: 0.117000\n",
      "(Epoch 4 / 20) train acc: 0.600000; val_acc: 0.134000\n",
      "(Epoch 5 / 20) train acc: 0.600000; val_acc: 0.122000\n",
      "(Iteration 11 / 40) loss: 3.886134\n",
      "(Epoch 6 / 20) train acc: 0.780000; val_acc: 0.123000\n",
      "(Epoch 7 / 20) train acc: 0.640000; val_acc: 0.127000\n",
      "(Epoch 8 / 20) train acc: 0.900000; val_acc: 0.129000\n",
      "(Epoch 9 / 20) train acc: 0.960000; val_acc: 0.121000\n",
      "(Epoch 10 / 20) train acc: 0.920000; val_acc: 0.126000\n",
      "(Iteration 21 / 40) loss: 1.012215\n",
      "(Epoch 11 / 20) train acc: 1.000000; val_acc: 0.131000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.131000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.131000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.131000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.131000\n",
      "(Iteration 31 / 40) loss: 0.000954\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.131000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.131000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.131000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.131000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.131000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a five-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "learning_rate = 3e-4  # Experiment with this!\n",
    "weight_scale = 1e-1   # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100, 100, 100],\n",
    "                weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()\n",
    "#不断陷入局部最优解。。。。。\n",
    "#试参数太难了"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 2: \n",
    "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?\n",
    "\n",
    "## Answer:\n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Update rules\n",
    "So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SGD+Momentum\n",
    "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n",
    "\n",
    "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  8.882347033505819e-09\n",
      "velocity error:  4.269287743278663e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.optim import sgd_momentum\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-3, 'velocity': v}\n",
    "next_w, _ = sgd_momentum(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n",
    "  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n",
    "  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n",
    "  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n",
    "expected_velocity = np.asarray([\n",
    "  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n",
    "  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n",
    "  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n",
    "  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n",
    "\n",
    "# Should see relative errors around e-8 or less\n",
    "print('next_w error: ', rel_error(next_w, expected_next_w))\n",
    "print('velocity error: ', rel_error(expected_velocity, config['velocity']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  sgd\n",
      "(Iteration 1 / 200) loss: 2.845100\n",
      "(Epoch 0 / 5) train acc: 0.075000; val_acc: 0.089000\n",
      "(Iteration 11 / 200) loss: 2.276888\n",
      "(Iteration 21 / 200) loss: 2.253674\n",
      "(Iteration 31 / 200) loss: 2.149682\n",
      "(Epoch 1 / 5) train acc: 0.233000; val_acc: 0.214000\n",
      "(Iteration 41 / 200) loss: 2.092103\n",
      "(Iteration 51 / 200) loss: 2.106342\n",
      "(Iteration 61 / 200) loss: 1.998104\n",
      "(Iteration 71 / 200) loss: 2.097670\n",
      "(Epoch 2 / 5) train acc: 0.295000; val_acc: 0.237000\n",
      "(Iteration 81 / 200) loss: 1.992633\n",
      "(Iteration 91 / 200) loss: 1.956169\n",
      "(Iteration 101 / 200) loss: 1.934245\n",
      "(Iteration 111 / 200) loss: 1.899844\n",
      "(Epoch 3 / 5) train acc: 0.296000; val_acc: 0.272000\n",
      "(Iteration 121 / 200) loss: 1.807413\n",
      "(Iteration 131 / 200) loss: 1.654609\n",
      "(Iteration 141 / 200) loss: 1.926284\n",
      "(Iteration 151 / 200) loss: 1.873385\n",
      "(Epoch 4 / 5) train acc: 0.329000; val_acc: 0.277000\n",
      "(Iteration 161 / 200) loss: 1.819719\n",
      "(Iteration 171 / 200) loss: 1.793061\n",
      "(Iteration 181 / 200) loss: 1.957020\n",
      "(Iteration 191 / 200) loss: 1.750441\n",
      "(Epoch 5 / 5) train acc: 0.350000; val_acc: 0.284000\n",
      "\n",
      "running with  sgd_momentum\n",
      "(Iteration 1 / 200) loss: 2.578368\n",
      "(Epoch 0 / 5) train acc: 0.115000; val_acc: 0.102000\n",
      "(Iteration 11 / 200) loss: 2.217268\n",
      "(Iteration 21 / 200) loss: 2.100303\n",
      "(Iteration 31 / 200) loss: 2.045124\n",
      "(Epoch 1 / 5) train acc: 0.311000; val_acc: 0.290000\n",
      "(Iteration 41 / 200) loss: 2.006856\n",
      "(Iteration 51 / 200) loss: 1.903492\n",
      "(Iteration 61 / 200) loss: 1.861355\n",
      "(Iteration 71 / 200) loss: 1.740208\n",
      "(Epoch 2 / 5) train acc: 0.415000; val_acc: 0.360000\n",
      "(Iteration 81 / 200) loss: 1.829514\n",
      "(Iteration 91 / 200) loss: 1.661826\n",
      "(Iteration 101 / 200) loss: 1.748545\n",
      "(Iteration 111 / 200) loss: 1.527934\n",
      "(Epoch 3 / 5) train acc: 0.466000; val_acc: 0.380000\n",
      "(Iteration 121 / 200) loss: 1.553172\n",
      "(Iteration 131 / 200) loss: 1.410859\n",
      "(Iteration 141 / 200) loss: 1.418392\n",
      "(Iteration 151 / 200) loss: 1.544900\n",
      "(Epoch 4 / 5) train acc: 0.478000; val_acc: 0.361000\n",
      "(Iteration 161 / 200) loss: 1.434672\n",
      "(Iteration 171 / 200) loss: 1.414039\n",
      "(Iteration 181 / 200) loss: 1.301644\n",
      "(Iteration 191 / 200) loss: 1.389346\n",
      "(Epoch 5 / 5) train acc: 0.549000; val_acc: 0.326000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\xc\\anaconda3\\envs\\tensorflow\\lib\\site-packages\\matplotlib\\figure.py:98: MatplotlibDeprecationWarning: \n",
      "Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  \"Adding an axes using the same arguments as a previous axes \"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_train = 4000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "solvers = {}\n",
    "\n",
    "for update_rule in ['sgd', 'sgd_momentum']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': 5e-3,\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in solvers.items():\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=\"loss_%s\" % update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=\"train_acc_%s\" % update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=\"val_acc_%s\" % update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RMSProp and Adam\n",
    "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n",
    "\n",
    "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n",
    "\n",
    "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n",
    "\n",
    "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n",
    "\n",
    "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  9.524687511038133e-08\n",
      "cache error:  2.6477955807156126e-09\n"
     ]
    }
   ],
   "source": [
    "# Test RMSProp implementation\n",
    "from cs231n.optim import rmsprop\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'cache': cache}\n",
    "next_w, _ = rmsprop(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n",
    "  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n",
    "  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n",
    "  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n",
    "expected_cache = np.asarray([\n",
    "  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n",
    "  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n",
    "  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n",
    "  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('cache error: ', rel_error(expected_cache, config['cache']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  0.0015218451757856217\n",
      "v error:  4.208314038113071e-09\n",
      "m error:  4.214963193114416e-09\n"
     ]
    }
   ],
   "source": [
    "# Test Adam implementation\n",
    "from cs231n.optim import adam\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n",
    "next_w, _ = adam(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n",
    "  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n",
    "  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n",
    "  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n",
    "expected_v = np.asarray([\n",
    "  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n",
    "  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n",
    "  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n",
    "  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n",
    "expected_m = np.asarray([\n",
    "  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n",
    "  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n",
    "  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n",
    "  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('v error: ', rel_error(expected_v, config['v']))\n",
    "print('m error: ', rel_error(expected_m, config['m']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  adam\n",
      "(Iteration 1 / 200) loss: 3.105446\n",
      "(Epoch 0 / 5) train acc: 0.145000; val_acc: 0.110000\n",
      "(Iteration 11 / 200) loss: 2.394559\n",
      "(Iteration 21 / 200) loss: 2.157027\n",
      "(Iteration 31 / 200) loss: 2.031720\n",
      "(Epoch 1 / 5) train acc: 0.275000; val_acc: 0.259000\n",
      "(Iteration 41 / 200) loss: 1.897034\n",
      "(Iteration 51 / 200) loss: 1.831347\n",
      "(Iteration 61 / 200) loss: 1.895995\n",
      "(Iteration 71 / 200) loss: 1.825429\n",
      "(Epoch 2 / 5) train acc: 0.310000; val_acc: 0.275000\n",
      "(Iteration 81 / 200) loss: 1.949645\n",
      "(Iteration 91 / 200) loss: 1.599306\n",
      "(Iteration 101 / 200) loss: 1.959303\n",
      "(Iteration 111 / 200) loss: 1.824608\n",
      "(Epoch 3 / 5) train acc: 0.351000; val_acc: 0.341000\n",
      "(Iteration 121 / 200) loss: 1.598100\n",
      "(Iteration 131 / 200) loss: 1.831647\n",
      "(Iteration 141 / 200) loss: 1.722921\n",
      "(Iteration 151 / 200) loss: 1.785722\n",
      "(Epoch 4 / 5) train acc: 0.411000; val_acc: 0.322000\n",
      "(Iteration 161 / 200) loss: 1.761935\n",
      "(Iteration 171 / 200) loss: 1.720990\n",
      "(Iteration 181 / 200) loss: 1.541017\n",
      "(Iteration 191 / 200) loss: 1.544254\n",
      "(Epoch 5 / 5) train acc: 0.456000; val_acc: 0.347000\n",
      "\n",
      "running with  rmsprop\n",
      "(Iteration 1 / 200) loss: 2.593679\n",
      "(Epoch 0 / 5) train acc: 0.164000; val_acc: 0.164000\n",
      "(Iteration 11 / 200) loss: 2.100869\n",
      "(Iteration 21 / 200) loss: 1.958498\n",
      "(Iteration 31 / 200) loss: 2.045357\n",
      "(Epoch 1 / 5) train acc: 0.359000; val_acc: 0.293000\n",
      "(Iteration 41 / 200) loss: 1.801307\n",
      "(Iteration 51 / 200) loss: 1.755826\n",
      "(Iteration 61 / 200) loss: 1.762399\n",
      "(Iteration 71 / 200) loss: 1.669973\n",
      "(Epoch 2 / 5) train acc: 0.399000; val_acc: 0.327000\n",
      "(Iteration 81 / 200) loss: 1.573247\n",
      "(Iteration 91 / 200) loss: 1.651563\n",
      "(Iteration 101 / 200) loss: 1.589238\n",
      "(Iteration 111 / 200) loss: 1.569202\n",
      "(Epoch 3 / 5) train acc: 0.458000; val_acc: 0.335000\n",
      "(Iteration 121 / 200) loss: 1.584611\n",
      "(Iteration 131 / 200) loss: 1.494548\n",
      "(Iteration 141 / 200) loss: 1.548081\n",
      "(Iteration 151 / 200) loss: 1.468748\n",
      "(Epoch 4 / 5) train acc: 0.495000; val_acc: 0.348000\n",
      "(Iteration 161 / 200) loss: 1.396874\n",
      "(Iteration 171 / 200) loss: 1.437649\n",
      "(Iteration 181 / 200) loss: 1.412796\n",
      "(Iteration 191 / 200) loss: 1.575842\n",
      "(Epoch 5 / 5) train acc: 0.520000; val_acc: 0.357000\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}\n",
    "for update_rule in ['adam', 'rmsprop']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': learning_rates[update_rule]\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 3:\n",
    "\n",
    "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n",
    "\n",
    "```\n",
    "cache += dw**2\n",
    "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n",
    "```\n",
    "\n",
    "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n",
    "\n",
    "\n",
    "## Answer: \n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a good model!\n",
    "Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.\n",
    "\n",
    "If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.\n",
    "\n",
    "You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "best_model = None\n",
    "################################################################################\n",
    "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
    "# find batch/layer normalization and dropout useful. Store your best model in  #\n",
    "# the best_model variable.                                                     #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "pass\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test your model!\n",
    "Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
    "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
    "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n",
    "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
